﻿using System;
using System.Collections.Generic;
using System.Text;

namespace Obsolete.VoIP.Getafisk.DLL_01BL_02netfx20.any_any_any
{
	[Serializable]
	public
		class 
		Extension
	{

		# region ---- Property int ExtensionNumber --------------------
		private int _ExtensionNumber;

		public int ExtensionNumber
		{
			get { return _ExtensionNumber; }
			set
			{
				if (value != _ExtensionNumber)
				{
					// lock(_ExtensionNumber) // MultiThread safe
					{
						_ExtensionNumber = value;
						if (null != ExtensionNumberChanged)
							ExtensionNumberChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler ExtensionNumberChanged;
		# endregion ---- int Property.ExtensionNumber --------------------
		
		# region ---- Property string DisplayName --------------------
		private string _DisplayName;

		public string DisplayName
		{
			get { return _DisplayName; }
			set
			{
				if (value != _DisplayName)
				{
					// lock(_DisplayName) // MultiThread safe
					{
						_DisplayName = value;
						if (null != DisplayNameChanged)
							DisplayNameChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler DisplayNameChanged;
		# endregion ---- string Property.DisplayName --------------------

		# region ---- Property string AliasCID --------------------
		private string _AliasCID;

		public string AliasCID
		{
			get { return _AliasCID; }
			set
			{
				if (value != _AliasCID)
				{
					// lock(_AliasCID) // MultiThread safe
					{
						_AliasCID = value;
						if (null != AliasCIDChanged)
							AliasCIDChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler AliasCIDChanged;
		# endregion ---- string Property.AliasCID --------------------

		# region ---- Property string AliasSIP --------------------
		private string _AliasSIP;

		public string AliasSIP
		{
			get { return _AliasSIP; }
			set
			{
				if (value != _AliasSIP)
				{
					// lock(_AliasSIP) // MultiThread safe
					{
						_AliasSIP = value;
						if (null != AliasSIPChanged)
							AliasSIPChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler AliasSIPChanged;
		# endregion ---- string Property.AliasSIP --------------------

		# region ---- Property string OutboundCID --------------------
		private string _OutboundCID;

		public string OutboundCID
		{
			get { return _OutboundCID; }
			set
			{
				if (value != _OutboundCID)
				{
					// lock(_OutboundCID) // MultiThread safe
					{
						_OutboundCID = value;
						if (null != OutboundCIDChanged)
							OutboundCIDChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler OutboundCIDChanged;
		# endregion ---- string Property.OutboundCID --------------------

		# region ---- Property int RingTime --------------------
		private int _RingTime;

		public int RingTime
		{
			get { return _RingTime; }
			set
			{
				if (value != _RingTime)
				{
					// lock(_RingTime) // MultiThread safe
					{
						_RingTime = value;
						if (null != RingTimeChanged)
							RingTimeChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler RingTimeChanged;
		# endregion ---- int Property.RingTime --------------------

		# region ---- Property bool CallWaiting --------------------
		private bool _CallWaiting;

		public bool CallWaiting
		{
			get { return _CallWaiting; }
			set
			{
				if (value != _CallWaiting)
				{
					// lock(_CallWaiting) // MultiThread safe
					{
						_CallWaiting = value;
						if (null != CallWaitingChanged)
							CallWaitingChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler CallWaitingChanged;
		# endregion ---- bool Property.CallWaiting --------------------

		# region ---- Property bool CallScreening --------------------
		private bool _CallScreening;

		public bool CallScreening
		{
			get { return _CallScreening; }
			set
			{
				if (value != _CallScreening)
				{
					// lock(_CallScreening) // MultiThread safe
					{
						_CallScreening = value;
						if (null != CallScreeningChanged)
							CallScreeningChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler CallScreeningChanged;
		# endregion ---- bool Property.CallScreening --------------------

		# region ---- Property string CIDEmergency --------------------
		private string _CIDEmergency;

		public string CIDEmergency
		{
			get { return _CIDEmergency; }
			set
			{
				if (value != _CIDEmergency)
				{
					// lock(_CIDEmergency) // MultiThread safe
					{
						_CIDEmergency = value;
						if (null != CIDEmergencyChanged)
							CIDEmergencyChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler CIDEmergencyChanged;
		# endregion ---- string Property.CIDEmergency --------------------

		# region ---- Property int Secret --------------------
		private int _Secret;

		public int Secret
		{
			get { return _Secret; }
			set
			{
				if (value != _Secret)
				{
					// lock(_Secret) // MultiThread safe
					{
						_Secret = value;
						if (null != SecretChanged)
							SecretChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler SecretChanged;
		# endregion ---- int Property.Secret --------------------

		# region ---- Property DIDCIDs DIDCIDCollection --------------------
		private DIDCIDs _DIDCIDCollection;

		public DIDCIDs DIDCIDCollection
		{
			get { return _DIDCIDCollection; }
			set
			{
				if (value != _DIDCIDCollection)
				{
					// lock(_DIDCIDCollection) // MultiThread safe
					{
						_DIDCIDCollection = value;
						if (null != DIDCIDCollectionChanged)
							DIDCIDCollectionChanged(this, new EventArgs());
					}
				}
			}
		}

		public event EventHandler DIDCIDCollectionChanged;
		# endregion ---- DIDCIDs Property.DIDCIDCollection --------------------
	
	}
}
